home *** CD-ROM | disk | FTP | other *** search
/ Floppyshop 2 / Floppyshop - 2.zip / Floppyshop - 2.iso / art&graf.ix / art-3484 / spufile / spufile.c < prev    next >
C/C++ Source or Header  |  1990-01-27  |  21KB  |  959 lines
  1. /*************************************************************
  2.  
  3.               Spufile   1.0
  4.  
  5.                 by
  6.  
  7.           Gregory Mathias Lemperle-Kerr
  8.  
  9. ***************************************************************
  10.     Synopsis:
  11.         This program will list the files on a mac
  12.         400/800/360/720K disk with the old mac
  13.         file system.
  14.         It can be used with MagicSac and/or Aladin/
  15.         SPUMAC 1 & 2 sided disks as well as Spectre 128
  16.         1 sided disks.
  17.         It is written to be a subroutine of SPUMACST.
  18.         It will then transfer a specified file from
  19.         the Mac type disk to a gem format diskette
  20.         in the form of file.mac, file.mrs and file.inf
  21.         (the data, resource & informative parts of the 
  22.         file respectively).
  23.         The .INF file is necessary for proper return
  24.         of the file to a mac type disk.
  25. **********************************************************************/
  26.  
  27. #include <stdio.h>
  28. #include <osbind.h>
  29.  
  30. #define unt    unsigned int
  31.  
  32. #define    MACINF    0x0
  33. #define MACDAT    0x1
  34. #define MACRSC    0x2
  35.  
  36. #define    READ    0x0
  37. #define    WRITE    0x1
  38. #define RW        0x2
  39.  
  40. int        rderr;
  41. unt        sec[256],
  42.         fat[512],
  43.         blk,
  44.         j,
  45.         i,
  46.         n,
  47.         fn,
  48.         disktype,
  49.         odsktype;
  50. long    bytesperdisk,
  51.         stflbk;
  52. char    s,
  53.         t,
  54.         sd,
  55.         k,
  56.         m,
  57.         *fbuf[2048];
  58. struct    STdisk
  59.         {
  60.         long    free;
  61.         long    total;
  62.         long    bps;
  63.         long    spc;
  64.         }
  65.         stdisk;
  66. struct    STfile
  67.         {
  68.         char    name[44];
  69.         long    bytes;
  70.         }
  71.         stdata[256],
  72.         strsrc[256],
  73.         stinfo[256];
  74. struct    appledisk
  75.         {
  76.         unt        hfs;
  77.         long    initdate;
  78.         long    backdate;
  79.         unt        attrib;
  80.         unt        files;
  81.         unt        directory;
  82.         unt        dirlen;
  83.         unt        blocks;
  84.         long    bpblk;
  85.         long    bytesperalo;
  86.         unt        firstblock;
  87.         long    filenum;
  88.         unt        freeblocks;
  89.         char    namelen;
  90.         char    name[26];
  91.         char    spt;
  92.         char    firsttrack;
  93.         char    sides;
  94.         char    spb;
  95.         }
  96.         macdisk,omacdsk;
  97. struct    applefile
  98.         {
  99.         unt        attrib;            /* char attrib + char version */
  100.         long    findera;
  101.         long    finderb;
  102.         long    finderc;
  103.         long    finderd;
  104.         long    filenum;
  105.         unt        datastart;
  106.         long    dataleof;
  107.         long    datapeof;
  108.         unt        rscstart;
  109.         long    rscleof;
  110.         long    rscpeof;
  111.         long    create;
  112.         long    lastmod;
  113.         char    namelen;
  114.         char    name[66];
  115.         }
  116.         macfile[256],
  117.         definfo;
  118.         
  119. memfree()
  120.     {
  121.     unt f=0;
  122.  
  123.     while (fbuf[f])    Mfree (fbuf[f++]);
  124.     }
  125.  
  126. leave()
  127.     {
  128.     memfree();
  129.     printf("\n\nPress RETURN to exit:");
  130.     fgetc(stdin);
  131.     exit();
  132.     }
  133.  
  134. errunkn(ek)
  135.     char    ek;
  136.     {
  137.     printf("\n%c%c%c Error number: %d !",0x7,0x7,0x7,ek);
  138.     leave();
  139.     }
  140.  
  141. memallo(z,amt)
  142.     unt     z;
  143.     long    amt;
  144.     {
  145.     if ( ( fbuf[z] = ( (char *) Malloc(amt) ) ) <= 0 ) errunkn(15);
  146.     }
  147.  
  148. readsec(sector,track,side,buf)
  149.     unt        sector;
  150.     unt        track;
  151.     unt        side;
  152.     char    *buf;
  153.     {    
  154.     if (rderr = Floprd(buf,0L,0,sector,track,side,1) != 0)
  155.         {
  156.         printf("\n Read error (%x) on side %d, track %d, sec %d!\n"
  157.             ,rderr,side,track,sector);
  158.         leave();
  159.         }
  160.     }
  161.  
  162. writsec(sector,track,side,buf)
  163.     unt        sector;
  164.     unt        track;
  165.     unt        side;
  166.     char    *buf;
  167.     {
  168.     if (rderr = Flopwr(buf,0L,0,sector,track,side,1) != 0)
  169.         {
  170.         printf("\n Write error (%x) on side %d, track %d, sec %d!\n"
  171.             ,rderr,side,track,sector);
  172.         leave();
  173.         }
  174.     }
  175.  
  176. dumpbuf(buf,bytes)
  177.     unt    buf;
  178.     unt    bytes;
  179.     {
  180.     char    c;
  181.     unt    x;
  182.     
  183.     printf(" >>> First %x bytes:",bytes);
  184.     for (x = 0 ; x < bytes ; x++)
  185.         {
  186.         c = *(fbuf[buf]+x);
  187.         if ( ( (c < 'A') || (c > 'Z') ) && ( (c < 'a') || (c > 'z') )
  188.            &&( (c < '0') || (c > '9') ) )
  189.             c = '_';
  190.         printf("%c",c);
  191.         }
  192.     printf("\015");
  193.     }
  194.     
  195. setMCnm(fname, type)
  196.     char    *fname;
  197.     char    type;
  198.     {
  199.     unt        pos;
  200.     int        filedes;
  201.     char    c;
  202.     
  203.     *(fname) = 'A';
  204.     *(fname+1) = ':';
  205.     for ( pos=0 ; (pos < 8) && ( macfile[fn].name[pos] ) ; pos++ )
  206.         {
  207.         c = macfile[fn].name[pos];
  208.         if ( ( (c < 'A') || (c > 'Z') ) && ( (c < 'a') || (c > 'z') )
  209.            &&( (c < '0') || (c > '9') ) )
  210.             c = '_';
  211.         *(fname+pos+2) = c;
  212.         }
  213.     *(fname+pos+2)='.';
  214.     switch (type)
  215.         {
  216.         case MACDAT:
  217.             *(fname+pos+3)='M';
  218.             *(fname+pos+4)='A';
  219.             *(fname+pos+5)='C';
  220.             break;
  221.         case MACRSC:
  222.             *(fname+pos+3)='M';
  223.             *(fname+pos+4)='R';
  224.             *(fname+pos+5)='S';
  225.             break;
  226.         default:
  227.             *(fname+pos+3)='I';
  228.             *(fname+pos+4)='N';
  229.             *(fname+pos+5)='F';
  230.             break;
  231.         }
  232.     *(fname+pos+6)=0x0;
  233.     printf("\n Wrote: %s - ",fname);
  234.     if ( Fsfirst(fname,0) >= 0 ) 
  235.         putover(fname);
  236.     filedes=Fcreate(fname,0x0);
  237.     if ( !filedes ) errunkn(21);
  238.     Fclose(filedes);
  239.     if ( filedes = Fopen(fname,WRITE) )
  240.         return(filedes);
  241.     errunkn(49);
  242.     }
  243.     
  244. setMCds()
  245.     {
  246.     if (sec[0] == 0xd2d7)
  247.         {
  248.         macdisk.hfs            = sec[0];
  249.         macdisk.initdate    = sec[1] * 0x10000 + sec[2];
  250.         macdisk.backdate    = sec[3] * 0x10000 + sec[4];
  251.         macdisk.attrib        = sec[5];
  252.         macdisk.files        = sec[6];
  253.         macdisk.directory    = sec[7];
  254.         macdisk.dirlen        = sec[8];
  255.         macdisk.blocks        = sec[9];
  256.         macdisk.bpblk        = sec[10] * 0x10000 + sec[11];
  257.         macdisk.bytesperalo    = sec[12] * 0x10000 + sec[13];
  258.         macdisk.firstblock    = sec[14];
  259.         macdisk.filenum        = sec[15] * 0x10000 + sec[16];
  260.         macdisk.freeblocks    = sec[17];
  261.         macdisk.namelen        = sec[18] / 0x100;
  262.         macdisk.spb            = macdisk.bpblk / 0x200;
  263.         for (i=0,j=0;i<macdisk.namelen;i++,j=j+2)
  264.             {
  265.             macdisk.name[j]        =sec[18+i];
  266.             macdisk.name[j+1]    =sec[18+i+1]/0x100;
  267.             }
  268.         macdisk.name[25]=macdisk.name[26]=0;
  269.         if (macdisk.namelen<24)
  270.             macdisk.name[macdisk.namelen]=macdisk.name[macdisk.namelen+1]=0;
  271.         bytesperdisk = macdisk.firstblock * 0x200 + macdisk.blocks * macdisk.bpblk;
  272.         }
  273.     else    macdisk.hfs = 0;
  274.     }
  275.         
  276. gettype()
  277.     {
  278.     disktype = 0;
  279.     readsec(0x03,0x00,0x00,sec);
  280.     if (sec[0] != 0xd2d7) Dfree(&stdisk,1);
  281.     setMCds();
  282.     if (macdisk.hfs == 0xd2d7)
  283.         {
  284.         macdisk.sides=0;
  285.         macdisk.spt=10;
  286.         macdisk.firsttrack=0;
  287.         if (bytesperdisk > 0x64000)
  288.             {
  289.             disktype = 4;
  290.             macdisk.sides = 1;
  291.             }
  292.         else disktype = 2;
  293.         }
  294.     else
  295.         {
  296.         readsec(0x0003,0x0001,0x0000,&sec[0]);
  297.         setMCds();
  298.         if (macdisk.hfs == 0xd2d7)
  299.             {
  300.             macdisk.spt =9 ;
  301.             macdisk.firsttrack = 1;
  302.             macdisk.sides = 0;
  303.             if (bytesperdisk > 0x58e00)
  304.                 {
  305.                 disktype = 3;
  306.                 macdisk.sides = 1;
  307.                 }
  308.             else disktype = 1;
  309.             }
  310.         }
  311.     if ( disktype ) getMCft();
  312.     else Dfree(&stdisk,1);
  313.     }
  314.  
  315. outtype()
  316.     {
  317.     printf("\n\n Type: %d - ",disktype);
  318.     switch (disktype)
  319.         {
  320.         case 0x1:
  321.             printf("SPUMAC / Aladin 1 side");
  322.             break;
  323.         case 0x2:
  324.             printf("MagicSac 1 side");
  325.             break;
  326.         case 0x3:
  327.             printf("SPUMAC / Aladin 2 sides");
  328.             break;
  329.         case 0x4:
  330.             printf("MagicSac 2 sides");
  331.             break;
  332.         default:
  333.             printf("GEM / PC");
  334.             break;
  335.         }
  336.     if (disktype)
  337.         {
  338.         printf("        Title: %s",macdisk.name);        
  339.         printf("\n Initialize Date:$%lx",macdisk.initdate);
  340.         printf("\n Backup Date    :$%lx",macdisk.backdate);
  341.         printf("\n Name Length    : %d",macdisk.namelen);
  342.         printf("\n Directory Start: %d",macdisk.directory);
  343.         printf("\n Directory Secs : %d",macdisk.dirlen);
  344.         printf("\n Attributes     :$%x",macdisk.attrib);
  345.         printf("\n Next Filenumber: %ld",macdisk.filenum);
  346.         printf("\n Number of files: %d",macdisk.files);
  347.         printf("\n First block    : %d",macdisk.firstblock);
  348.         printf("\n Total blocks   : %d",macdisk.blocks);
  349.         printf("\n Free blocks    : %d",macdisk.freeblocks);
  350.         printf("\n Bytes per block: %ld",macdisk.bpblk);
  351.         printf("\n Secs per block : %d",macdisk.spb);
  352.         printf("\n Bytes per alloc: %ld",macdisk.bytesperalo);
  353.         printf("\n Bytes per disk : %ld",bytesperdisk);
  354.         }
  355.     else
  356.         {
  357.         printf("\n Total CLUS:%ld",stdisk.total);
  358.         printf("\n Free  CLUS:%ld",stdisk.free);
  359.         printf("\n Sec / CLUS:%ld",stdisk.spc);
  360.         printf("\n Byte / Sec:%ld\n",stdisk.bps);
  361.         printf("\n Free Space:%ld\n\n",stdisk.free * stdisk.bps * stdisk.spc);
  362.         }
  363.     }
  364.  
  365.  
  366. setMCin()
  367.     {
  368.     sec[0]    =    macfile[fn].attrib;
  369.     sec[1]    =    macfile[fn].findera / 0x10000;
  370.     sec[2]    =    macfile[fn].findera;
  371.     sec[3]    =    macfile[fn].finderb / 0x10000;
  372.     sec[4]    =    macfile[fn].finderb;
  373.     sec[5]    =    macfile[fn].finderc / 0x10000;
  374.     sec[6]    =    macfile[fn].finderc;
  375.     sec[7]    =    macfile[fn].finderd / 0x10000;
  376.     sec[8]    =    macfile[fn].finderd;
  377.     sec[9]    =    macfile[fn].create / 0x10000;
  378.     sec[10]    =    macfile[fn].create;
  379.     sec[11]    =    macfile[fn].lastmod / 0x10000;
  380.     sec[12]    =    macfile[fn].lastmod;
  381.     sec[13] =    macfile[fn].namelen * 0x100 + macfile[fn].name[0];
  382.     for (k=m=1;(k<64) && (k<macfile[fn].namelen);k++,m=m+2)
  383.         sec[13+k] = macfile[fn].name[m+1] + (macfile[fn].name[m] * 0x100);
  384.     for (m=k ; m < 64 ; m++) sec[13+m]=0;
  385.     }
  386.     
  387. setMCdr()
  388.     {
  389.     macfile[j].attrib        =sec[n+0];
  390.     macfile[j].findera        =sec[n+1]*0x10000L+sec[n+2];
  391.     macfile[j].finderb        =sec[n+3]*0x10000L+sec[n+4];
  392.     macfile[j].finderc        =sec[n+5]*0x10000L+sec[n+6];
  393.     macfile[j].finderd        =sec[n+7]*0x10000L+sec[n+8];
  394.     macfile[j].filenum        =sec[n+9]*0x10000L+sec[n+10];
  395.     macfile[j].datastart    =sec[n+11];
  396.     macfile[j].dataleof        =sec[n+12]*0x10000L+sec[n+13];
  397.     macfile[j].datapeof        =sec[n+14]*0x10000L+sec[n+15];
  398.     macfile[j].rscstart        =sec[n+16];
  399.     macfile[j].rscleof        =sec[n+17]*0x10000L+sec[n+18];
  400.     macfile[j].rscpeof        =sec[n+19]*0x10000L+sec[n+20];
  401.     macfile[j].create        =sec[n+21]*0x10000L+sec[n+22];
  402.     macfile[j].lastmod        =sec[n+23]*0x10000L+sec[n+24];
  403.     macfile[j].namelen        =sec[n+25]/0x100;
  404.     for (k=m=0;(k<64) && (k<macfile[j].namelen);k++,m=m+2)
  405.         {
  406.         macfile[j].name[m]        =sec[n+25+k];
  407.         macfile[j].name[m+1]    =sec[n+25+k+1]/0x100;
  408.         }
  409.     macfile[j].name[macfile[j].namelen]=macfile[j].name[macfile[j].namelen+1]=0;
  410.     n=n+25+macfile[j].namelen/2;
  411.     }
  412.     
  413. getMCdr()
  414.     {
  415.     j = sd = 0;
  416.     s = macdisk.directory;
  417.     s++;
  418.     t = macdisk.firsttrack;
  419.     for ( i = 0 , sec[0] = 0x8000; (sec[0] == 0x8000) && (i <= 255) ; i++ )
  420.         {
  421.         readsec(s,t,sd,&sec[0]);
  422.         n = 0;
  423.         while (n <= 255)
  424.             {
  425.             if (sec[n] == 0x8000)
  426.                 {
  427.                 setMCdr();
  428.                 macfile[++j].attrib=0;
  429.                 }
  430.             ++n;
  431.             }
  432.         if (++s > macdisk.spt)
  433.             {
  434.             s=1;
  435.             if (macdisk.sides == 0)
  436.                 ++t;
  437.             else if ((sd = 1 - sd) == 0)
  438.                 ++t;
  439.             }
  440.         }
  441.     }
  442.     
  443. setMCft()
  444.     {
  445.     fat[j+0] =  (sec[i+0]/0x10);
  446.     fat[j+1] = ((sec[i+0]&0x000F)*0x100)+(sec[i+1]/0x100 );
  447.     fat[j+2] = ((sec[i+1]&0x00FF)*0x10 )+(sec[i+2]/0x1000);
  448.     fat[j+3] =  (sec[i+2]&0x0FFF);
  449.     }
  450.  
  451. getMCft()
  452.     {
  453.     readsec(0x0003,macdisk.firsttrack,0x0000,&sec[0]);
  454.     
  455.     for (i = 32, j = 0; j < 296; i = i + 3, j = j + 4)    setMCft();
  456.     fat[296] =  (sec[254]/0x10);
  457.     fat[297] = ((sec[254]&0x000F)*0x100)+(sec[255]/0x100);
  458.     fat[298] =  (sec[255]&0x00ff)*0x10;
  459.     
  460.     readsec(0x0004,macdisk.firsttrack,0x0000,&sec[0]);
  461.     
  462.     for ( i = 1 , j = 300 ; j < 509 ; i = i + 3 , j = j + 4 )    setMCft();
  463.     fat[298] = fat[298]+(sec[0]/0x1000);
  464.     fat[299] = sec[0]&0x0fff;
  465.     }
  466.  
  467. setMCbk(b, sc, tk, sd)
  468.     unt    b,
  469.         *sc,
  470.         *tk,
  471.         *sd;
  472.     {
  473.     *sd  = 0;
  474.     *tk = macdisk.firsttrack;
  475.     for ( *sc = (b - 2) * macdisk.spb + macdisk.firstblock + 1;
  476.           *sc > macdisk.spt ; *sc = ( *sc - macdisk.spt) )
  477.         {
  478.         if (macdisk.sides == 0)
  479.             ++*tk;
  480.         else if (( *sd = (1 - *sd)) == 0)
  481.             ++*tk;
  482.         }
  483.     }
  484.  
  485. gptMCbk(rw, b, z)
  486.     char    rw;
  487.     unt     b,
  488.             z;
  489.     {
  490.     unt        sector,
  491.             track,
  492.             side,
  493.             count;
  494.     char    *fb;
  495.  
  496.     setMCbk(b, §or, &track, &side);
  497.     memallo(z,macdisk.bpblk);
  498.     fb = fbuf[z];
  499.     for ( count = 0 ; count < macdisk.spb ; count++ )
  500.         {
  501.         if ( rw )     writsec(sector,track,side,fb);
  502.         else        readsec(sector,track,side,fb);
  503.         fb = fb + 0x200;
  504.         if ((++sector) > macdisk.spt)
  505.             {
  506.             sector = 1;
  507.             if (macdisk.sides == 0)
  508.                 ++track;
  509.             else if ((side = (1 - side)) == 0)
  510.                 ++track;
  511.             }
  512.         }
  513.     }
  514.  
  515. putMCdt()
  516.     {
  517.     }
  518.     
  519. putMCrs()
  520.     {
  521.     }
  522.  
  523. putMCin()
  524.     {
  525.     }
  526.  
  527. getMCdt()
  528.     {
  529.     unt        z;
  530.     unt        current;
  531.     
  532.     current = macfile[fn].datastart;
  533.     for (z = blk; (z-blk) < (macfile[fn].datapeof / macdisk.bpblk); z++)
  534.         {
  535.         printf(" Reading data block %4x: %4x",z,current);
  536.         gptMCbk(READ,current,z);
  537.         dumpbuf(z,20);
  538.         current = fat[current - 2 ];
  539.         }
  540.     blk = z;
  541.     }
  542.  
  543. getMCrs()
  544.     {
  545.     unt        z;
  546.     unt        current;
  547.  
  548.     current = macfile[fn].rscstart;
  549.     for (z = blk; (z-blk) < (macfile[fn].rscpeof / macdisk.bpblk); z++)
  550.         {
  551.         printf(" Reading rsrc block %4x: %4x\n",z,current);
  552.         gptMCbk(READ,current,z);
  553.         current = fat[current - 2 ];
  554.         }
  555.     blk = z;
  556.     }
  557.  
  558. putSTdt(fd)
  559.     int fd;
  560.     {
  561.     unt        z;
  562.     long    last;
  563.     last = 0;
  564.     for (z = blk; (z-blk + 1) < (macfile[fn].datapeof / omacdsk.bpblk); z++)
  565.         {
  566.         printf("%4x ",z);
  567.         if (!Fwrite(fd,omacdsk.bpblk,fbuf[z])) errunkn(3);
  568.         last = last + omacdsk.bpblk;
  569.         }
  570.     printf("%4x ",z);
  571.     if (!Fwrite(fd,macfile[fn].dataleof-last,fbuf[z++])) errunkn(4);
  572.     blk = z;
  573.     }
  574.  
  575. putSTrs(fd)
  576.     int fd;
  577.     {
  578.     unt        z;
  579.     long    last;
  580.     last = 0;
  581.     for (z = blk; (z-blk + 1) < (macfile[fn].rscpeof / omacdsk.bpblk); z++)
  582.         {
  583.         printf("%4x ",z);
  584.         if (!Fwrite(fd,omacdsk.bpblk,fbuf[z])) errunkn(6);
  585.         last = last + omacdsk.bpblk;
  586.         }
  587.     printf("%4x ",z);
  588.     if (!Fwrite(fd,macfile[fn].rscleof-last,fbuf[z++])) errunkn(5);
  589.     blk = z;
  590.     }
  591.  
  592. setSTdr(path,dta)
  593.     char    *path;
  594.     char    *dta;
  595.     {
  596.     unt    y,
  597.         z;
  598.     
  599.     stdata[fn].bytes = *( (long *)(dta + 26) );
  600.     for ( y=0 ; ( stdata[fn].name[y] = *(path + y) ) ; y++ );
  601.     y = y - 3;
  602.     for ( z = y ; z < ( y + 14 ) ; z++ )
  603.         stdata[fn].name[z]     = *(dta + z - y + 30);
  604.     stdata[fn].name[z] = 0;
  605.     stdata[++fn].name[0] = 0;
  606.     }
  607.  
  608. getSTdr()
  609.     {
  610.     char    drive[32];
  611.     
  612.     drive[0] = 'A';
  613.     drive[1] = ':';
  614.     drive[2] = 0x5c;
  615.     drive[3] = 0x2a;
  616.     drive[4] = '.';
  617.     drive[5] = 0x2a;
  618.     drive[6] = 0x0;    
  619.     getSTpt(&drive[0]);
  620.     }
  621.     
  622. getSTpt(path)
  623.     char    *path;
  624.     {
  625.     int        new;
  626.     unt        z,
  627.             deep=0,
  628.             p;
  629.     char    *dta,
  630.             temp[32];
  631.     
  632.     printf("Searching: %-44s\n",path);
  633.     if (Fsfirst(path,0) >=0    ) setSTdr( path, (char *)Fgetdta() );
  634.     while ( Fsnext() >= 0 ) setSTdr ( path, (char *)Fgetdta() );
  635.     new = Fsfirst(path,0x10);
  636.     dta = (char *)Fgetdta();
  637.     while ( ( ( *(dta+30) == 0x2e ) || ( *(dta+21) != 0x10 ) ) 
  638.                                     && ( ( new = Fsnext() ) >= 0 ) )
  639.         dta = ( (char *)Fgetdta() );
  640.     while (new >= 0)
  641.         {
  642.         for( p = 0 ; p < 32 ; p++) temp[p]=*(path+p);
  643.         for ( p = 0 ; temp[p] ; p++);
  644.         p = p - 3;
  645.         for ( z = p ; ( (z-p) < 14) && ( temp[z] = *(dta+z-p+30) ) ; z++ );
  646.         temp[z  ] = 0x5c;
  647.         temp[z+1] = 0x2a;
  648.         temp[z+2] = '.';
  649.         temp[z+3] = 0x2a;
  650.         temp[z+4] = 0x0;
  651.         getSTpt(&temp[0]);
  652.         new = Fsfirst(path,0x10);
  653.         dta = (char *)Fgetdta();
  654.         while ( ( ( *(dta+30) == 0x2e ) || ( *(dta+21) != 0x10 ) ) 
  655.                                         && ( ( new = Fsnext() ) >= 0 ) )
  656.             dta = ( (char *)Fgetdta() );
  657.         ++deep;
  658.         for(z = deep ; z && (new >= 0) ; z--)
  659.             {
  660.             new = Fsnext();
  661.             dta = (char *)Fgetdta();
  662.             if ( (new >= 0) && ( *(dta+21) != 0x10 ) ) z++;
  663.             }
  664.         }
  665.     }
  666.     
  667. outSTdr()
  668.     {
  669.     char    pos;
  670.     
  671.     printf("\n\n Press RETURN to see file listing of %d files:",fn);
  672.     fgetc(stdin);
  673.  
  674.     printf("\n\nChoice Pathname                                    Length");
  675.     printf(  "\n------ ----------------------------------------    ------");
  676.     
  677.     for (i=0;stdata[i].name[0];i++)
  678.         printf("\n%-7d%-44s%6ld",i,((&stdata[i])->name) + 2,stdata[i].bytes);
  679.     printf(  "\n------ ----------------------------------------    ------\n");
  680.     }
  681.  
  682. choSTfl()
  683.     {
  684.     long    freemem;
  685.     unt        f;
  686.     char    *stf;
  687.     
  688.     outSTdr();
  689.     freemem = Malloc(-1L);
  690.     printf("Free Memory:%ld bytes,   Transfer:",freemem);
  691.     scanf("%d",&f);
  692.     getc(stdin);
  693.     if (f > fn)
  694.         {
  695.         printf("\nNot a valid choice!%c",7);
  696.         leave();
  697.         }
  698.     fn = f;
  699.     stf = ( (&stdata[fn])->name );
  700.     for ( f = 0 ; (f < 44) && *(stf + f) ; f++ )
  701.         stinfo[fn].name[f] = ( strsrc[fn].name[f] = *(stf + f) );
  702.     f = f - 3;
  703.     stinfo[fn].name[f  ] = 'I';
  704.     stinfo[fn].name[f+1] = 'N';
  705.     stinfo[fn].name[f+2] = 'F';
  706.     strsrc[fn].name[f  ] = 'R';
  707.     strsrc[fn].name[f+1] = 'S';
  708.     strsrc[fn].name[f+2] = 'C';
  709.     strsrc[fn].bytes = 0x0L;
  710.     stinfo[fn].bytes = 0x0L;
  711.     
  712.     if ( ( ( *(stf+f) != 'R' ) || ( *(stf+f+1) != 'S' ) || ( *(stf+f+2) != 'C' ) )
  713.             && ( Fsfirst( (&strsrc[fn])->name, 0 ) >= 0 ) )
  714.         {
  715.         stf = (char *)Fgetdta();
  716.         strsrc[fn].bytes = *((long *)(stf + 26));
  717.         }
  718.     if ( ( ( *(stf+f) != 'I' ) || ( *(stf+f+1) != 'N' ) || ( *(stf+f+2) != 'F' ) )
  719.             && ( Fsfirst( (&stinfo[fn])->name, 0 ) >= 0 ) )
  720.         {
  721.         stf = (char *)Fgetdta();
  722.         stinfo[fn].bytes = *((long *)(stf + 26));
  723.         }
  724.     if (freemem < ( stdata[fn].bytes + strsrc[fn].bytes +stinfo[fn].bytes ) )
  725.         {
  726.         printf("\nNot enough memory for that file!%c",7);
  727.         leave();
  728.         }
  729.     }
  730.  
  731. getSTfl()
  732.     {
  733.     unt        z;
  734.     
  735.     getSTdr();
  736.     choSTfl();
  737.     
  738.     getSTst( (&stdata[fn])->name, stdata[fn].bytes );
  739.     if ( strsrc[fn].bytes ) getSTst( (&strsrc[fn])->name, strsrc[fn].bytes);
  740.     if ( stinfo[fn].bytes ) getSTst( (&stinfo[fn])->name, stinfo[fn].bytes);
  741.     }
  742.  
  743. getSTst(stf, length)
  744.     char    *stf;
  745.     long    length;
  746.     {
  747.     int        fd;
  748.     unt        z;
  749.     long    crap;
  750.         
  751.     if (Fsfirst(stf,0) < 0 )
  752.         {
  753.         printf("File %s was not found!%c",stf,0x7);
  754.         leave();
  755.         }
  756.     crap = Fgetdta();
  757.     if ( ( fd = Fopen(stf,READ) ) < 0 ) errunkn(37);
  758.     printf("Reading: %s\n",stf);
  759.     for ( z=blk ; (z - blk + 1) < (length / 0x200L ) ; z++ )
  760.         {
  761.         memallo(z,0x200L);
  762.         Fread(fd,0x200L,fbuf[z]);
  763.         }
  764.     memallo(z,0x200L);
  765.     Fread(fd,(length - ( (z - blk + 1) * 0x200L) ), fbuf[z++]);
  766.     blk = z;
  767.     Fclose(fd);
  768.     }
  769.  
  770. putSTst(stf,length)
  771.     char    *stf;
  772.     long    length;
  773.     {
  774.     int fd;
  775.     unt    z;
  776.  
  777.     printf("Writing: %s\n",stf);
  778.     if (Fsfirst(stf,0) >= 0 ) putover(stf);
  779.     if ( ( fd = Fcreate(stf,0) ) < 0 ) errunkn(39);
  780.     Fclose(fd);
  781.     if ( ( fd = Fopen(stf,WRITE) ) < 0 ) errunkn(31);
  782.     for ( z=blk ; (z - blk + 1) < (length / 0x200 ) ; z++ )
  783.         Fwrite(fd,0x200L,fbuf[z]);
  784.     Fwrite(fd,(length - ( (z - blk + 1) * 0x200L) ), fbuf[z++]);
  785.     blk = z;
  786.     Fclose(fd);
  787.     }
  788.  
  789. putSTfl()
  790.     {
  791.     long    dblk,
  792.             iblk,
  793.             rblk,
  794.             STbpc;
  795.     int        filedes;
  796.     char    stfname[44],
  797.             *inb;
  798.  
  799.     Dfree(&stdisk,1);    
  800.     STbpc= stdisk.bps * stdisk.spc;
  801.     iblk = (odsktype > 0);
  802.     dblk = (iblk * macfile[fn].datapeof / STbpc ) 
  803.             + ((1-iblk) * stflbk);
  804.     rblk = iblk * macfile[fn].rscpeof / STbpc;
  805.     
  806.     printf("\n CLUSTERS- Free:%ld > Need: Data:%ld, Resource:%ld, Info:%ld.\n",
  807.         stdisk.free,dblk,rblk,iblk);
  808.     if ( stdisk.free < (dblk + iblk + rblk))
  809.         {
  810.         printf("Not enough space!");
  811.         leave();
  812.         }
  813.     else
  814.         {
  815.         if (!iblk)
  816.             {
  817.             putSTst( (&stdata[fn])->name );
  818.             if ( strsrc[fn].bytes ) putSTst( (&strsrc[fn])->name, strsrc[fn].bytes );
  819.             if ( strsrc[fn].bytes ) putSTst( (&stinfo[fn])->name, stinfo[fn].bytes );            
  820.             }
  821.         else
  822.             {
  823.             filedes = setMCnm(&stfname[0],MACINF);
  824.             setMCin();
  825.             if (!Fwrite(filedes,0x50L,&sec[0])) errunkn(2);
  826.             if (Fclose(filedes) < 0) errunkn(1);
  827.             if (macfile[fn].dataleof)
  828.                 {
  829.                 filedes = setMCnm(&stfname[0],MACDAT);
  830.                 putSTdt(filedes);
  831.                 if (Fclose(filedes) < 0) errunkn(1);
  832.                 }
  833.             if (macfile[fn].rscleof)
  834.                 {
  835.                 filedes = setMCnm(&stfname[0],MACRSC);
  836.                 putSTrs(filedes);
  837.                 if (Fclose(filedes) < 0) errunkn(1);
  838.                 }
  839.             }
  840.         }
  841.     }
  842.     
  843. putover(fname)
  844.     char    *fname;
  845.     {
  846.     char    response;
  847.     
  848.     printf("\n Do you wish to overwrite %s y/n:",fname);
  849.     scanf("%c",&response);
  850.     fgetc(stdin);
  851.     
  852.     if ( ( response='n' ) || ( Fdelete(fname) < 0x0) )
  853.         {
  854.         printf("\n Error deleting old file!%c",0x7);
  855.         leave();
  856.         }        
  857.     }
  858.         
  859. getfile()
  860.     {
  861.     if ( disktype )
  862.         {
  863.         getMCdr();
  864.         choMCfl();
  865.         if ( macfile[fn].datastart )    getMCdt();
  866.         if ( macfile[fn].rscstart )        getMCrs();
  867.         }
  868.     else getSTfl();
  869.     }
  870.  
  871. putfile()
  872.     {
  873.     if ( disktype )
  874.         {
  875.         if ( macfile[fn].datastart )         putMCdt();
  876.         if ( macfile[fn].rscstart )        putMCrs();
  877.         putMCin();
  878.         }
  879.     else putSTfl();
  880.     }
  881.     
  882. outMCdr()
  883.     {
  884.     char    fname[9],
  885.             pos;
  886.     
  887.     fname[8] = 0;
  888.     
  889.     printf("\n\n Press RETURN to see file listing:");
  890.     fgetc(stdin);
  891.  
  892.     printf("\n\nChoice Filename   DatLen   DatUse     RscLen   RscUse        MemUse");
  893.     printf(  "\n------ --------   ------   ------     ------   ------        ------\n");
  894.     
  895.     for (i=0;((macfile[i].attrib == 0x8000) && (i<=255));i++)
  896.         {
  897.         for(pos = 0; (pos < 8) && (macfile[i].name[pos]) ; pos++)
  898.             fname[pos]=macfile[i].name[pos];
  899.         fname[pos]=0;
  900.         printf("%-7d",i);
  901.         printf("%-8s",fname);
  902.         printf("%9ld%9ld%11ld%9ld%14ld\n",
  903.             macfile[i].dataleof,macfile[i].datapeof,
  904.             macfile[i].rscleof,macfile[i].rscpeof,
  905.             macfile[i].datapeof+macfile[i].rscpeof);
  906.         }
  907.     printf("------ --------   ------   ------     ------   ------        ------\n");
  908.     }
  909.     
  910. choMCfl()
  911.     {
  912.     long    freemem;
  913.     
  914.     outMCdr();
  915.     freemem = Malloc(-1L);
  916.     printf("Free Memory:%ld bytes,   Transfer:",freemem);
  917.     scanf("%d",&fn);
  918.     getc(stdin);
  919.     if (fn > macdisk.files)
  920.         {
  921.         printf("\nNot a valid choice!%c",7);
  922.         leave();
  923.         }
  924.     if (freemem < (macfile[fn].datapeof + macfile[fn].rscpeof))
  925.         {
  926.         printf("\nNot enough memory for that file!%c",7);
  927.         leave();
  928.         }
  929.     }
  930.  
  931.     
  932. main()
  933.     {
  934.     Dsetdrv(0x0);
  935.     
  936.     printf(" SPUFILE 1.0  (GAMMA) by Gregory Mathias Lemperle-Kerr  (C) 1989!  Gem:%4x\n\n",
  937.         (Sversion()) );
  938.     printf("\n Insert source in A:\n\n Press RETURN when ready:");
  939.     fgetc(stdin);
  940.     
  941.     gettype();
  942.     outtype();
  943.     blk = 0;
  944.     getfile();
  945.     
  946.     odsktype = disktype;
  947.     omacdsk = macdisk;
  948.     
  949.     printf("\n Insert destination in A:\n\n Press RETURN when ready:");
  950.     fgetc(stdin);
  951.     
  952.     gettype();
  953.     outtype();
  954.     blk = 0;    
  955.     putfile();
  956.     
  957.     leave();
  958.     }
  959.